/*
HORUSv0.0.7 4-7-2011
Modificaciones: 
- Cambiar cadena nido para asignar automaticamente direcciones.
- La balanza se puede dejar desconectada en el caso de no estar operativa.
 */

#include "HorusClasses.h"
#include "OneWire.h"
#include "SHT1x.h"
#include "Wire.h"
#include <Ethernet.h>
//#include <SPI.h>
//#define byte uint8_t 

char nido[4]="PRB";

// Configuracion a modificar siempre que se utilice una nueva placa arduino que controle a un objeto distinto a los previamente instalados.
// Parametros configuracion ethernet e IP
byte mac[] = { 0x00, 0x02, 0xD1, 0x04, 0x22, 0x04 };
byte ip[] = { 192, 168, 1, 119};
byte gateway[] = { 192, 168, 1, 1};
byte subnet[] = { 255, 255, 255, 0 };

// Puerto de comunicacion.
// Servidor 1: para comunicacion con cliente de java por el puerto 80.
// Servidor 2: para comunicacion con cliente de telnet, para controlar el programa, por el puerto 23.
#define PUERTO 80
#define PUERTO2 23
Server server(PUERTO); 
Server server2(PUERTO2);


// RTC.
int var;
#define DS1307_ADDRESS 0x68
int second;
int minute;
int hour; //De 0 a 24
int weekDay; //De 0 (domingo) a 6 (sabado). No se va a usar.
int monthDay;
int month;
int year;

int contador=0;

// Sensor de temperatura y humedad.
//#define dataPin 20
//#define clockPin 21
// PINES ALTERNATIVOS Sensor de temperatura y humedad.
#define dataPin 14//26 //14//En arduino 4º pin de la izquierda empezando por arrriba del conector digital. En CON_2 pin 11.
#define clockPin 15//28 //15//En arduino 6º pin de la izquierda empezando por arrriba del conector digital. En CON_2 pin 12.
SHT1x sht1x(dataPin, clockPin);
float temp_c;
float humidity;

// Sensores de temperatura
#define ONE_WIRE_BUS 22 
OneWire oneWire(ONE_WIRE_BUS); 
//DallasTemperature sensors(&oneWire); 
//DeviceAddress insideThermometer;
//DeviceAddress insideThermometer1;

byte i;
byte present = 0;
byte data[12];
byte addr1[8]={0x28, 0x99, 0xB2, 0x15, 0x03, 0x00,0x00,0xA8};  //SENSOR EXTERNO
char addr1c[17]={'2','8','9','9','B','2','1','5','0','3','0','0','0','0','A','8','\0'};
float Temp1;
byte addr2[8]={0x28, 0xDB, 0xED, 0x15, 0x03, 0x00,0x00,0x49};  //SENSOR INTERNO
char addr2c[17]={'2','8','D','B','E','D','1','5','0','3','0','0','0','0','4','9','\0'};
float Temp2;

// Lector RFID
char* datos=(char*) calloc(20,sizeof(char)); //Tambien para la balanza
uint8_t* datosRFID=(uint8_t*) calloc(22,sizeof(uint8_t));
uint8_t e=0;
String codigo_rfid= String(30);  
String codigoHEX = String(30);

// Balanza
#define umbral 50 
float valor=0;
float valor_ant=0;
float tara=0;
float margen=0.5; //error en medida de tara 0.5 gramos
uint8_t mode=0;
unsigned long tiempo = 0;
unsigned long time_ant = 0;
uint8_t error=0;  
boolean balanzaconectada = true;
boolean pruebabalanza = false;

// Detectores de paso
// x1-IR1:BARRERA IR 1, SENSOR DE PASO 1, --PIN A0--
// x2-IR2:BARRERA IR 2, SENSOR DE PASO 2, --PIN A2--
// x3-IR3:BARRERA IR 3, BALANZA, --PIN A1--

//Por si varia valores de los pines: x1_2, x1_3, x2_2, x2_3, x3_2, x3_3

int x1=0;
int x1_2=0;
int x1_3=0;
boolean x1_onlyone=true;
int x2=0;
int x2_2=0;
int x2_3=0;
boolean x2_onlyone=true;
int x3=0;
int x3_2=0;
int x3_3=0;
boolean x3_onlyone=true;
int pinIR1= A0;
int pinIR2= A2;  //PUEDE QUE HAYA QUE CAMBIAR pinIR2=A1, pinIR3=A2
int pinIR3= A1;
#define umbralsuperior 400//530//450
#define umbralinferior 300//500//200


// Tramas enviadas al cliente
int evento=0; //16 bits de entero con signo desde -32768 hasta 32767 
#define maxLength 500
//String trama= String(maxLength);  
//char aux2[200];
//char aux_float2[6];
char aux2[200];
char aux_float2[6];

String aux=String(200);
String aux_float=String(6);




// ------------------------------------------------------------ SETUP ------------------------------------------------------------


void setup(void)
{
  
  
  pinMode(4,OUTPUT);
  digitalWrite(4,HIGH);
  
  Serial.begin(115200);
  delay(100);
  Serial.println("");
  Serial.println("--SETUP1--");
  
  
  //****************SELECCION DEL NIDO****************//
  
  seleccionnido();
  
  //Serial.println(direccion);
  Serial.println();
  Serial.print("NIDO: ");
  Serial.println(nido);
  Serial.print("IP: ");
  Serial.print("192.168.2.");
  Serial.println(ip[3],DEC);
  Serial.print("MAC: ");
  if(mac[5]>9){
    Serial.print("00-02-D1-04-22-");
  }else{
     Serial.print("00-02-D1-04-22-0");
  }
  Serial.println(mac[5],HEX);
  Serial.print("DIR. SENSOR EXT.: ");
  Serial.println(addr1c);
  Serial.print("DIR. SENSOR INT.: ");
  Serial.println(addr2c);
  Serial.println();
  
  
  //****************CONEXION ETHERNET****************//
  // iniciar la conexion ethernet
  Ethernet.begin(mac, ip, gateway, subnet);
  // comenzar la escucha de clientes
  server.begin();
  server2.begin();
 
  
  //****************LECTOR RFID**********************//
  //A 19200 bps tarda 0.416666 milisegundos en leer un byte.
  //El lector cuando detecta un tag envía el código en un mensaje 30 bytes para ISO animal
  //Además habría que sumarle los bits de inicio y stop introducidos por en el nivel físico que supondrían 7.5 Bytes, 
  //lo que daría un total de 37.5 Bytes y supone 15.625 milisegundos en recibir el total del mensaje.
  //Esto significa que para leer un tag necesitamos esperar aproximadamente 15.625 milisegundos.
  UCSR1C=B00000110;
  Serial1.begin(19200);
   
  //******************BALANZA***********************//
    //A 9600 bps tarda 0.8333 milisegundos en leer un byte.
  //La balanza envía 20 byte en cada serie de datos y a cada byte se le añade 3 bits (Inicio/Stop/Paridad),
  //además se envían envían en 7 bits por lo que al no ser multiplo de 8 siempre se tendrá que enviar más tramas.
  //Se mandan 20 Bytes en tramas de 7 + 3 bits lo que supone 20*8/7=22.8 ==> 23 tramas * 10 bits = 230 bits 
  //Se tarda 23.958333 milisegundos en enviar un mensaje. 
  //Se envían 16 series por segundo que supone un tiempo de 16*23.958333 = 0.38333 s un total de 383.33 ms
  UCSR2C=B00110100;
  Serial2.begin(9600);
 
  Serial.println("--SETUP2--"); 


  //********************RTC*****************************//
  Wire.begin();
  delay(500);

  Serial.println("--SETUP3--");
  
//  Establecer una hora inicial en setup.
  second=00;
  minute=35;
  hour=20;; //24 hour time
  weekDay=3; //0-6 -> sunday - Saturday
  monthDay=24;
  month=6;
  year=11;
  var=1;
  delay(100);
  setDateTime();

  delay(200);
     

    
  Serial.println("SETUP finalizado");
  Serial.println(" ");
  
  delay(2000);
  
  
  //  Serial.println("PRUEBA GETRAW");
  //  Peso.getRaw();

   
}


// ------------------------------------------------------------ LOOP ------------------------------------------------------------

void loop(void) {

 
  Client client=server.available();
  Client client2=server2.available(); 
  
  //Serial.println("prueba getRaw");
  //datos=Peso.getRaw();
  //Serial.println("finprueba getRaw");
  
  
  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // TRAMAS DE PRUEBA 
  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  char buff[200];
  char buff1[200]="ISO-FDX-B Animal";
  char buff2[200]="00004DE373";
  char buff3[200]="953";
  char buff4[200];
  char buff5[200];
  char buff6[200];
  float medida=99.9;
  float valor=28.5;

  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // FIN DE TRAMAS DE PRUEBA /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  //
  // ARDUINO DE PRUEBA: NO SE COMPRUEBAN LOS SENSORES DE TEMPERTURA Y LAS TRAMAS QUE SE ENVIAN LAS GENERA EL PROPIO ARDUINO. VER ETIQUETA @PRUEBA
  //
  
  
  // @PRUEBA
  
  if(strcmp(nido,"PRB")!=0){
  
///////////////////////////////////////////////PRUEBA DE LOS SENSORES DE TEMPERATURA/////////////////////////////////////////////
  
  Serial.println("**LECTURA DE TEMPERATURAS**");
 
  Serial.println("*SENSOR 1 EXTERNO*");

  Serial.print("DIRECCION SENSOR 1 = ");

  Serial.print(addr1c);

  oneWire.reset();
  delay(100);
  oneWire.select(addr1);
  delay(100);
  oneWire.write(0x44,1);	   // start conversion, with parasite power on at the end
  delay(1000);                     // maybe 750ms is enough, maybe not
  present = oneWire.reset();
  delay(100);
  oneWire.select(addr1);
  delay(100);
  oneWire.write(0xBE);	           // read Scratchpad
  delay(100);

  for ( i = 0; i < 9; i++) {
    data[i] = oneWire.read();
  }

  Serial.println(" ");
  
  Temp1=(data[1]<<8)+data[0];      //two bytes from the response relating to temperature
  Temp1=Temp1/16;

  Serial.print("TEMPERATURA SENSOR 1 = ");
  Serial.print(Temp1);
  Serial.println("  ");

  Serial.println("*SENSOR 2 INTERNO*");

  Serial.print("DIRECCION SENSOR 2 = ");

  Serial.print(addr2c);

  oneWire.reset();
  delay(100);
  oneWire.select(addr2);
  delay(100);
  oneWire.write(0x44,1);	   // start conversion, with parasite power on at the end
  delay(1000);                     // maybe 750ms is enough, maybe not
  present = oneWire.reset();
  delay(100);
  oneWire.select(addr2);
  delay(100);
  oneWire.write(0xBE);	           // read Scratchpad
  delay(100);

  for ( i = 0; i < 9; i++) {
    data[i] = oneWire.read();
  }

  Serial.println(" ");

  Temp2=(data[1]<<8)+data[0];     //two bytes from the response relating to temperature
  Temp2=Temp2/16;

  Serial.print("TEMPERATURA SENSOR 2 = ");
  Serial.print(Temp2);
  Serial.println("  ");

 Serial.println("**FIN LECTURA DE TEMPERATURAS**");
  
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  // Objeto cliente
  //client = server.available();
  //client2 = server2.available();
 
  imprimirpunto("--L1--",client2);
  

 
  
  // --------------------------------------------------- LOOP: SIN CONEXION AL CLIENTE --------------------------------------------
  
  //--LOCAL--
  //Comprobando si hay cliente conectado
  if(client.connected()==false){
     Serial.println("NO CONECTADO");
     if(client2.connected()==true){
     client2.println("CLIENTE DE JAVA NO CONECTADO");}
     
  }
 
 
  imprimirpunto("--L2--",client2);
   
 
  //RTC

  //Imprimir fecha por el puerto serie
  Serial.print("FECHA RTC: "); 
  if(client2.connected()==true){
     client2.println("FECHA RTC");}  
  var=1;
  printDate();
  delay(1000);
  Serial.print(month);
     if(client2.connected()==true){
     client2.print(month);}
  Serial.print("/");
     if(client2.connected()==true){
     client2.print("/");}
  Serial.print(monthDay);
     if(client2.connected()==true){
     client2.print(monthDay);}
  Serial.print("/");
     if(client2.connected()==true){
     client2.print("/");}
  Serial.print(year);
     if(client2.connected()==true){
     client2.print(year);}
  Serial.print(" ");
     if(client2.connected()==true){
     client2.print(" ");}
  Serial.print(hour);
     if(client2.connected()==true){
     client2.print(hour);}
  Serial.print(":");
     if(client2.connected()==true){
     client2.print(":");}
  Serial.print(minute);
     if(client2.connected()==true){
     client2.print(minute);}
  Serial.print(":");
     if(client2.connected()==true){
     client2.print(":");}
  Serial.println(second);
     if(client2.connected()==true){
     client2.println(second);}
     
     
    imprimirpunto("--L3--",client2);
  
  
  
  // SENSOR DE TEMPERATURA Y HUMEDAD 

  temp_c = sht1x.readTemperatureC();
  humidity = sht1x.readHumidity();
  Serial.println("SENSOR DE TEMPERATURA Y HUMEDAD");
  Serial.println("Humedad relativa (%): ");
  Serial.println(humidity);
  Serial.println("Temperatura (grados C): ");
  Serial.println(temp_c);
  if(client2.connected()==true){
     client2.println("SENSOR DE TEMPERATURA Y HUMEDAD");}
  if(client2.connected()==true){
     client2.println("Humedad relativa (%): ");}
  if(client2.connected()==true){
     client2.println(humidity);}
  if(client2.connected()==true){
     client2.println("Temperatura (grados C): ");}
  if(client2.connected()==true){
     client2.println(temp_c);}
     
     
     imprimirpunto("--L4--",client2);



  // SENSORES DE TEMPERATURA

//  //sensors.requestTemperatures(); // Comandos para solicitar temperaturas a los sensores 
//  Serial.println("SENSORES DE TEMPERATURA");
//  if(client2.connected()==true){
//     client2.println("SENSORES DE TEMPERATURA");}
//
//  char temp_cbuff[200];
//
//  //temp_c = sensors.getTempC(insideThermometer); //Sensor 0
//  dtostrf(temp_c,5,2,temp_cbuff); // ****  
//  Serial.println("Temperatura de sensor 0 (grados C): "); 
//  Serial.println(temp_cbuff);
//  if(client2.connected()==true){
//     client2.println("Temperatura de sensor 0 (grados C): ");}
//  if(client2.connected()==true){
//     client2.println(temp_cbuff);}
//  delay(1000);
//
//  //temp_c = sensors.getTempC(insideThermometer1); //Sensor 1
//  dtostrf(temp_c,5,2,temp_cbuff); // ****
//  Serial.println("Temperatura de sensor 1 (grados C): ");   
//  Serial.println(temp_cbuff);
//  if(client2.connected()==true){
//     client2.println("Temperatura de sensor 1 (grados C): ");}
//  if(client2.connected()==true){
//     client2.println(temp_cbuff);}
//  delay(1000);
  

  imprimirpunto("--L5--",client2);
  
            
  // DETECTORES IR

  Serial.println("DETECTORES IR");

  if(client2.connected()==true){
     client2.println("DETECTORES IR");}


  x1 = analogRead(pinIR1);

  Serial.print("Valor de x1: ");
  Serial.println(x1);
  Serial.print("Valor de x1_onlyone: ");
  Serial.println(x1_onlyone,DEC);
  if(client2.connected()==true){
     client2.println("Valor de x1: ");}
  if(client2.connected()==true){
     client2.println(x1);}
  if(client2.connected()==true){
     client2.println("Valor de x1_onlyone: ");}
  if(client2.connected()==true){
     client2.println(x1_onlyone,DEC);}

  if(x1>umbralsuperior && x1_onlyone){
      x1_onlyone=false;    
      Serial.println("--IR1 DETECTADO--");
      if(client2.connected()==true){
         client2.println("--IR1 DETECTADO--");}
  }else{
      if(x1<umbralinferior){
          x1_onlyone=true; 
      }                                
  }

  imprimirpunto("--L6--",client2);
  
  x2 = analogRead(pinIR2);

  Serial.print("Valor de x2: ");
  Serial.println(x2);
  Serial.print("Valor de x2_onlyone: ");
  Serial.println(x2_onlyone,DEC);
  if(client2.connected()==true){
     client2.println("Valor de x2: ");}
  if(client2.connected()==true){
     client2.println(x2);}
  if(client2.connected()==true){
     client2.println("Valor de x2_onlyone: ");}
  if(client2.connected()==true){
     client2.println(x2_onlyone,DEC);}

  if(x2>umbralsuperior && x2_onlyone){
      x2_onlyone=false;    
     Serial.println("--IR2 DETECTADO--");
     if(client2.connected()==true){
        client2.println("--IR2 DETECTADO--");}
  }else{
      if(x2<umbralinferior){
          x2_onlyone=true; 
      }                                
  }

  imprimirpunto("--L7--",client2);
    
  x3 = analogRead(pinIR3);

  Serial.print("Valor de x3: ");
  Serial.println(x3);
  Serial.print("Valor de x3_onlyone: ");
  Serial.println(x3_onlyone,DEC);
  if(client2.connected()==true){
     client2.println("Valor de x3: ");}
  if(client2.connected()==true){
     client2.println(x3);}
  if(client2.connected()==true){
     client2.println("Valor de x3_onlyone: ");}
  if(client2.connected()==true){
     client2.println(x3_onlyone,DEC);}

  if(x3>umbralsuperior && x3_onlyone){
      x3_onlyone=false;    
      Serial.println("--IR3 DETECTADO--");
      if(client2.connected()==true){
         client2.println("--IR3 DETECTADO--");}
  }else{
      if(x3<umbralinferior){
          x3_onlyone=true; 
      }                                
  }

  imprimirpunto("--L8--",client2);
  
  delay(100);
  
  
  //@PRUEBA
  }
  

// ---------------------------------------------- LOOP: CON CONEXION AL CLIENTE --------------------------------------------------

// Envio de los datos al cliente procedentes de los siguientes dispositivos
/*****************
device=0 unknown
device=1 inout1
device=2 inout2
device=3 rfid
device=4 balanza
device=5 DS18B20
device=6 SHT71
******************/

   
   while (client.connected()) {
     
   // Para poder crear el cliente de telnet
   // una vez que se ha conectado el cliente de java
   if(client2.connected()==false)
       client2 = server2.available();
     

  imprimirpunto("--C1--",client2);
  
  
  
  //
  // ARDUINO DE PRUEBA: SE VAN A LEER LOS SENSORES, SINO QUE SE VAN A ENVIAR TRAMAS DE PRUEBA.  @PRUEBA
  //
  
  // @PRUEBA
  
  if(strcmp(nido,"PRB")!=0){
    
  // ///////////////////////////////////////////////////////////////////////////////////////////////////////
  // COMIENZO DE LECTURA DE LOS EVENTOS
  // /////////////////////////////////////////////////////////////////////////////////////////////////////// 
  

            
  //************************************************//
  //****************Detectores de paso**************//
  //************************************************//

    Serial.println("IR1");
    if(client2.connected()==true){
        client2.println("IR1");}

    //Sensor de paso1

    x1 = analogRead(pinIR1);
    delay(1);
    x1_2 = analogRead(pinIR1);
    delay(1);
    x1_3 = analogRead(pinIR1);
    Serial.println("Valor de x1:");
    Serial.println(x1);
    if(client2.connected()==true){
        client2.println("x1: ");}
    if(client2.connected()==true){
        client2.println(x1);}

    if((x1>umbralsuperior) && (x1_2>umbralsuperior) && (x1_3>umbralsuperior) &&(x1_onlyone)){

         Serial.println("IR1 DETECTADO");
         if(client2.connected()==true){
            client2.println("IR1 DETECTADO");}

         x1_onlyone=false;    
         setdata(client,'1', "");

         imprimirpunto("--C2--",client2);

         Serial.println("Valor de x1:");
         Serial.println(x1);
         if(client2.connected()==true){
            client2.println("x1: ");}
         if(client2.connected()==true){
            client2.println(x1);}

          x3 = analogRead(pinIR3);

            if(x3<umbralsuperior && balanzaconectada){ //Obtengo tara si no hay activado la barrera IR de la balanza

         imprimirpunto("--C3--",client2);
            
            //Obtengo el mensage de peso en bruto
             datos=Peso.getRaw();

             if(datos[0]!='E' && datos[0]!='O'){ 

                   //Obtengo el valor en gramos del peso
                    tara=Peso.getValue(datos);
             }
         imprimirpunto("--C4--",client2);
           } 

         
         imprimirpunto("--C5--",client2);
                
    }else{
         if(x1<umbralinferior){
              x1_onlyone=true; 
         imprimirpunto("--C6--",client2);
         }                                
    }

 
         imprimirpunto("--C7--",client2);
         imprimirpunto("--IR2--",client2);

            
   //Sensor de paso2

   x2 = analogRead(pinIR2);
   delay(1);
   x2_2 = analogRead(pinIR2);
   delay(1);
   x2_3 = analogRead(pinIR2);
   
   Serial.println("Valor de x2:");
   Serial.println(x2);
   if(client2.connected()==true){
       client2.println("x2: ");}
   if(client2.connected()==true){
       client2.println(x2);}

   if((x2>umbralsuperior) && (x2_2>umbralsuperior) && (x2_3>umbralsuperior) && (x2_onlyone)){

         Serial.println("IR2 DETECTADO");
         if(client2.connected()==true){
                client2.println("IR2 DETECTADO");}

         x2_onlyone=false;    
         setdata(client,'2', "");

         imprimirpunto("--C8--",client2);
         
         Serial.println("Valor de x2:");
         Serial.println(x2);
         if(client2.connected()==true){
            client2.println("x2: ");}
         if(client2.connected()==true){
            client2.println(x2);}

            x3 = analogRead(pinIR3);

            if(x3<umbralsuperior && balanzaconectada){ //Obtengo tara si no hay activado la barrera IR de la balanza

         imprimirpunto("--C9--",client2);
            
            //Obtengo el mensage de peso en bruto
             datos=Peso.getRaw();

             if(datos[0]!='E' && datos[0]!='O'){ //NUEVO

                   //Obtengo el valor en gramos del peso
                    tara=Peso.getValue(datos);
             }
         imprimirpunto("--C10--",client2);

          } 
         
         imprimirpunto("--C11--",client2);
         
   }else{
        if(x2<umbralinferior){
             x2_onlyone=true; 
         imprimirpunto("--C12--",client2);
        }   
   }


         imprimirpunto("--C13--",client2);
         imprimirpunto("--RFID--",client2);
  
          
  //************************************************//
  //**************** LECTOR RFID *******************//
  //************************************************//

char codigo_rfid_buffer[30];  
char codigoHEX_buffer[30];
char inforfid[200];


   if(Serial1.available()>0){

    Serial.println("DATOS RFID DISPONIBLES");

    if(client2.connected()==true){
        client2.println("DATOS RFID DISPONIBLES");}

    //obtengo los datos brutos transmitidos por el lector RFID
    datosRFID=rfid.getRaw(&e);
         
         imprimirpunto("--C14--",client2);

    //Compruebo si se han recibido bien
    if(e>0 && datosRFID[0]!='A'){

         imprimirpunto("--C15--",client2);
              
               e=0;
                 
               //limpio datos anteriores
               //codigo_rfid.clear(); // quitar
               
               //Obtengo el codigo hexadecimal transmitido
               //codigo_rfid.append(rfid.getCodigoHEX(datosRFID,8)); 
               strcpy(codigo_rfid_buffer,rfid.getCodigoHEX(datosRFID,8));
                   
               //limpio datos anteriores                             
               //codigoHEX.clear(); // quitar
               //Decodifico el código para transmitirlo
               //No es soportado la conversion a formato numérico por tener 15 dígitos
               //codigoHEX.append(rfid.getCodigo(codigo_rfid.getChars())); 
               strcpy(codigoHEX_buffer,rfid.getCodigo(codigo_rfid_buffer));
                
               //Obtengo el codigo del pais                  
               //int pais =rfid.getPais(codigo_rfid.getChars());
               int pais = rfid.getPais(codigo_rfid_buffer);
               char paisbuff[20];
               itoa(pais,paisbuff,10); 
                                  
               //Compongo mensaje a enviar                 
               //aux.clear(); // quitar
               //aux.append(rfid.tipe(datosRFID)); 
               strcpy(inforfid,rfid.tipe(datosRFID));
               //aux.append(";");  
               strcat(inforfid,";");
               //aux.append(codigoHEX.getChars()); 
               strcat(inforfid,codigoHEX_buffer);
               //aux.append(";");   
               strcat(inforfid,";");
               //aux.append(pais); 
               strcat(inforfid,paisbuff);      
            
               imprimirpunto("--C16--",client2);
                                                         
               setdata(client,'3', inforfid); 
               
               imprimirpunto("--C17--",client2);
                               
       }else{
         
         
               imprimirpunto("--C18--",client2);
         
              //Si se detecta algún error envía una alarma
              setdata(client,'3', "ALARMA");

               imprimirpunto("--C19--",client2);
              
       }
 }  



         imprimirpunto("--C20--",client2);


          
  //************************************************//
  //**************** BALANZA ***********************//
  //************************************************//

 char infobalanza[200];
 char valorbuff[6];
 char tarabuff[6];
 char modebuff[6];
   
 Serial.println("BALANZA");
 Serial.println("Valor de x3:"); 
 x3 = analogRead(pinIR3);
 Serial.println(x3);
 
 if(client2.connected()==true){
    client2.println("BALANZA");}
 if(client2.connected()==true){
    client2.println("x3:");}
 if(client2.connected()==true){
    client2.println(x3);}
 
 
 
  if((x3> umbralsuperior && balanzaconectada) || pruebabalanza ){  
   
 
      Serial.println("DATOS BALANZA");
      if(client2.connected()==true){
          client2.println("DATOS BALANZA");}
       
       //Se toman los datos del puerto serie 2, en el caso de que los haya

       if (Serial2.available()>0) {
         
         
             imprimirpunto("--C21--",client2);
         
       
             //Obtengo el mensage de peso en bruto 
             datos=Peso.getRaw();
             
            imprimirpunto("--C22--",client2);
             
             
             //OPCION 1: no hay alarma

             if(datos[0]!='E' && datos[0]!='O'){ 
               
                   imprimirpunto("--C23--",client2);
                                
                   //Obtengo el valor en gramos del peso
                    valor=Peso.getValue(datos);
                    
                    //Obtengo el modo de adquisición de la medida (Estable/Inestable/ERROR)
                    mode=Peso.getMode(datos);

                    imprimirpunto("--C24--",client2);

                    
                    //Compruebo si es un peso real
                    if(valor>tara+umbral){
                      
                          //aux.clear(); 
                          //aux_float.clear(); 
                          //dtostrf(valor,4,2,aux_float); 
                          dtostrf(valor,4,2,valorbuff);
                          //aux.append(aux_float.getChars());
                          strcpy(infobalanza,valorbuff);
                          //aux.append(";"); 
                          strcat(infobalanza,";");
                          //aux.append(mode); 
                          itoa(mode,modebuff,10);
                          strcat(infobalanza,modebuff);
                       
                          //aux.append(";");
                          strcat(infobalanza,";"); 
                      
                          //dtostrf(tara,4,2,aux_float);
                          dtostrf(tara,4,2,tarabuff);
                          //aux.append(aux_float.getChars());
                          strcat(infobalanza,tarabuff);
                          Serial.println("PESO MEDIDO");
                          //setdata(client,'4', aux.getChars()); 

                          imprimirpunto("--C25--",client2);

                          Serial.println(infobalanza);
                          if(client2.connected()==true){
                                client2.println(infobalanza);}

                          imprimirpunto("--C26--",client2);

                        ///////////////////////////////////////////


                          setdata(client,'4', infobalanza); 

                          imprimirpunto("--C27--",client2);
                          
                  
                          valor_ant=valor;  //Para comparar en la siguiente iteracion
                          time_ant=millis();//Para comparar en la siguiente iteracion
                          if(tiempo<0) tiempo=0; //--
                          

                    }
                    
                    imprimirpunto("--C28--",client2);
                    
 
                    error=0;
                    
                // OPCION 2: alarma por error u overload.
                    
                }else{  //  else DE  if(datos[0]!='E' && datos[0]!='O'){

                     imprimirpunto("--C29--",client2);
                  
                  
                     Serial.println(datos[0]);

                     if(datos[0]=='O'){
                      //aux.clear();                     
                      //aux.append("ALARMA;OVERLOAD"); 
                      strcpy(infobalanza,"ALARMA;OVERLOAD");
                      Serial.println("ALARMA;OVERLOAD");
                      if(client2.connected()==true){
                          client2.println("ALARMA;OVERLOAD");}
                      //setdata(client,'4', aux.getChars()); 

                      setdata(client,'4',infobalanza);

                      imprimirpunto("--C30--",client2);
                      error=0;
                      
                     }else{
                    
                        imprimirpunto("--C31--",client2);
                    
                    
                        if(error>=100){
                          if(error == 100){
                          //aux.clear();    //
                          //aux.append("ALARMA;ERROR");
                          strcpy(infobalanza,"ALARMA;ERROR");
                          //setdata(client,'4', aux.getChars());
                          Serial.println("ALARMA;ERROR");
                          if(client2.connected()==true){
                            client2.println("ALARMA;ERROR");}

                          setdata(client,'4',infobalanza);

                          imprimirpunto("--C32--",client2);
                          error=0;
                         }
                       }else{
                       error++;
                       }
                    
                       imprimirpunto("--C33--",client2);
                      
                   }
                  

                }  // CIERRE DE  else DE  if(datos[0]!='E' && datos[0]!='O'){
                
                   imprimirpunto("--C34--",client2);
               
                
              }  //CIERRE (if(Serial2.available()>0)
       
    }  //CIERRE if(x3>umbralsuperior)


 imprimirpunto("--C35--",client2);
 
  // //////////////////////////////////////////////////////////////////////////////////////////////
  // FIN DE LECTURA DE LOS EVENTOS
  // ////////////////////////////////////////////////////////////////////////////////////////////// 
 
 
 
   //@PRUEBA
  }


  // @PRUEBA
  
  if(strcmp(nido,"PRB")!=0){



  // //////////////////////////////////////////////////////////////////////////////////////////////
  // COMIENZO DE COMPROBACION DE PETICIONES RECIBIDAS DEL CLIENTE
  // ////////////////////////////////////////////////////////////////////////////////////////////// 

  

  //************************************************//
  //******** SENSORES DE TEMPERATURA ***************//
  //******** SENSOR DE TEMPERATURA Y HUMEDAD********//
  //************************************************//  
  //    GET;5 : peticion de temperatura y humedad a sensor SHT71
  //    GET;6;DIR : peticion de temperatura a sensor DS18B20

   
imprimirpunto("--C36--",client2);
     
  char c='0';
  char cbuff[2];
  //aux.clear();
  int i=0;
  
  char peticioncliente[200]; //Sustituye a aux
  //char* peticioncliente=(char*) calloc(100,sizeof(char));
  peticioncliente[0]='\0';
  peticioncliente[1]='\0';
  peticioncliente[2]='\0';
  peticioncliente[3]='\0';
  peticioncliente[4]='\0';

  while (client.available() && c!='\n' ) {
    
        Serial.println("LECTURA DE LA PETICION DEL CLIENTE");              
        c = client.read();
        cbuff[0]=c;
        cbuff[1]='\0';
        //Serial.println(cbuff[0]);
        if(i==0){
        strcpy(peticioncliente,cbuff);}
        else{strcat(peticioncliente,cbuff);}
        //Serial.println(peticioncliente);
        i++;
  }
  
        Serial.println("LECTURA DE LA PETICION DEL CLIENTE 2"); 
  
  imprimirpunto("--C37--",client2);

  Serial.print("Peticion del cliente: ");
  Serial.println(peticioncliente);
  if(client2.connected()==true){
        client2.println("Peticion del cliente");}

  //MODIFICACIONES JULIO
  if(client2.connected()==true){
          client2.println(peticioncliente);}

  imprimirpunto("--C38--",client2);
  
    
  if((peticioncliente[0]=='G' && peticioncliente[4]=='5') || (peticioncliente[3]=='5')){
    
   Serial.println("PETICION TEMPERATURA Y HUMEDAD");
   if(client2.connected()==true){
        client2.println("PETICION TEMPERATURA Y HUMEDAD");}
           
  //SI es GET;5 hay que obtener la temperatura y humedad del sensor 
  //y enviarla al servidor mediante SET;5;TEMP;HUMEDAD
     
   temp_c = sht1x.readTemperatureC();
   humidity = sht1x.readHumidity();
   
   //23 DE AGOSTO. MODIFICACION PARA 6S1
   //4 reintentos para cuando la temperatura o humedad no sean validas
//      int q=0;
//      while(((temp_c<0)||(humidity<0)||(temp_c>100)||(humidity>100))&&q<4){
//         q++;
//         temp_c = sht1x.readTemperatureC();
//         humidity = sht1x.readHumidity();
//      }
   
   
   dtostrf(temp_c,3,2,buff);
   strcat(buff,";");
   dtostrf(humidity,3,2,buff1);
   strcat(buff,buff1);
 
   imprimirpunto("--C39--",client2);


  //MODIFICACIONES JULIO

  Serial.println(buff);
  if(client2.connected()==true){
      client2.println(buff);}

  imprimirpunto("--C40--",client2);

  ///////////////////////////////////////////



   setdata(client,'5', buff);

   imprimirpunto("--C41--",client2);

 }
 
   imprimirpunto("--C42--",client2);
                   
                
 //SI es GET;6;DIR tengo que obtener la temperatura del sensor con DIR
 //y enviarla al servidor mediante SET;6;DIR;TEMP
       
 if(peticioncliente[0]=='G' && peticioncliente[4]=='6'){
   
     
     imprimirpunto("PETICION DE TEMPERATURAS",client2);   
      //divido el mensaje en la parte de direccion del sensor substring();

      //sensors.requestTemperatures(); 
      
     imprimirpunto("SENSOR 0",client2);
      
      //MODIFICACION PARA PEDIR LA TEMPERATURA
      pedirTemperatura();
      
      //3 reintentos para cuando la temperatura no sea valida 
      int k=0;
      while(((Temp1<0)||(Temp2<0)||(Temp1>100)||(Temp2>100))&&k<3){
         k++;
         pedirTemperatura();
      }
      
      
      dtostrf(Temp1,5,2,buff); // ****
      strcat(buff,";");
      strcat(buff,addr1c);
      
      //temp_c = sensors.getTempC(insideThermometer); 
      //dtostrf(temp_c,5,2,buff); // ****
      //strcat(buff,";");
      //strcat(buff,getAddress(insideThermometer));
      
      imprimirpunto("--C43--",client2);

      //MODIFICACIONES JULIO

      Serial.println(buff);
      if(client2.connected()==true){
               client2.println(buff);}

      imprimirpunto("--C44--",client2);

      ///////////////////////////////////////////


      setdata(client,'6', buff);

      imprimirpunto("--C45--",client2);
      
      imprimirpunto("--SENSOR1--",client2);
            
      
        
      //MODIFICACION PARA PEDIR LA TEMPERATURA
      //pedirTemperatura();
      dtostrf(Temp2,5,2,buff); // ****
      strcat(buff,";");
      strcat(buff,addr2c);
        
      //temp_c = sensors.getTempC(insideThermometer1); 
      //dtostrf(temp_c,5,2,buff); // ****
      //strcat(buff,";");
      //strcat(buff,getAddress(insideThermometer1));
     
      imprimirpunto("--C46--",client2);     

      setdata(client,'6', buff);

      imprimirpunto("--C47--",client2);
          
 }
 
      imprimirpunto("--C48--",client2);


  //************************************************//
  //********* RTC: ESTABLECER FECHA ****************//
  //************************************************//  

//Formato de la trama recibida para establecer fecha:
//SET;7;ss;mm;hh;dm;ms;year
//donde:
//ss: segundo.
//mm: minuto.
//hh: hora.
//dm: dia del mes.
//ms: mes.
//year: año (4 digitos)

   if(peticioncliente[0]=='S' && peticioncliente[4]=='7'){
     
     Serial.println("--RTC:ESTABLECER FECHA--");   
     if(client2.connected()==true){
        client2.println("--RTC:ESTABLECER FECHA--");}

     //SEGUNDO      
     char secondc[3]= {peticioncliente[6],peticioncliente[7]};
     second=atoi(secondc);
     //--LOCAL--
//     Serial.println(second);
      
     //MINUTO 
     char minutec[3] ={peticioncliente[9],peticioncliente[10]};
     minute=atoi(minutec);
     //--LOCAL--
//     Serial.println(minute);
       
     //HORA 
     char hourc[3] ={peticioncliente[12],peticioncliente[13]};
     hour=atoi(hourc);
          //--LOCAL--
//     Serial.println(hour);
       
//   //DIA DE LA SEMANA: No se va a utilizar
//   char weekDayc[3] ={aux[15],aux[16]};
//   weekDay=atoi(weekDayc);
//   Serial.println(weekDay);
       
     //DIA DEL MES
     char monthDayc[3] ={peticioncliente[15],peticioncliente[16]};
     monthDay=atoi(monthDayc);
     //--LOCAL--
//     Serial.println(monthDay);
       
     //MES
     char monthc[3] ={peticioncliente[18],peticioncliente[19]};
     month=atoi(monthc);
     //--LOCAL--
//     Serial.println(month);
       
     //AÑO
     char yearc[3] ={peticioncliente[23],peticioncliente[24]};
     year=atoi(yearc);
     //--LOCAL--
//     Serial.println(year);

    
      var=1;
      setDateTime(); 
      delay(500);
      
      imprimirpunto("--FIN RTC:ESTABLECER FECHA--",client2);
   
                
  }       
  
  
      // aux.clear();
      // aux_float.clear();
      
      
      // ESTE RETARDO SE PUEDE AUMENTAR PARA PROBAR HACER UNA PETICION POR TELNET
      delay(50);
      

  // //////////////////////////////////////////////////////////////////////////////////////////////
  // FIN DE COMPROBACION DE PETICIONES RECIBIDAS DEL CLIENTE
  // ////////////////////////////////////////////////////////////////////////////////////////////// 



      
  }

  
// if (!client.connected()) {
//       delay(100);
//    Serial.println("disconnecting.");
//    client.stop();
//   
//  }

  // //////////////////////////////////////////////////////////////////////////////////////////////
  // COMIENZO CODIGO DE PRUEBA: TRAMAS ENVIADAS Y RECIBIDAS DEL CLIENTE CONTROLADAS A CONTINUACION
  // //////////////////////////////////////////////////////////////////////////////////////////////   
      
  // @PRUEBA
  
    if (client.available()) {
    
        Serial.println("LECTURA DE LA PETICION DEL CLIENTE");              
        char c = client.read();
        Serial.println(c);
  }
  
       Serial.println("Trama de prueba segunda");
  
  if(strcmp(nido,"PRB")==0){
    
    
    char tramaprueba[50]="prueba de trama enviada al cliente";
    //strcpy(tramaprueba, "ESTO ES LA TRAMA DE PRUEBA PRIMERA");
    
    char tramaprueba2[50];
    //strcpy(tramaprueba2, "ESTA ES LA TRAMA DE PRUEBA SEGUNDA");
    
 
    
    //delay(5000);
    Serial.println("MODO DE PRUEBA.");
    delay(10);
    
    // PRUEBA DE ENVIO DE DATOS AL CLIENTE
     if(client.connected()==true){
     Serial.println("Trama de prueba primera");

     //client.println(tramaprueba);
     client.println(tramaprueba);
     //Serial.println(tramaprueba);
     //client.write('A');
     //client.flush();
     delay(1000);
     }
     
    
     //if(client.connected()==true&&i==1){
     //Serial.println("Trama de prueba segunda");  
     //client.println("XXTrama de prueba segundaYY");
     //client.write('B');
     //delay(100);
     //}
     
   contador=contador+1;
    
    // PRUEBA DE RECEPCION DE DATOS AL CLIENTE
    
    
    
        
  }


  // //////////////////////////////////////////////////////////////////////////////////////////////
  // FIN CODIGO DE PRUEBA: TRAMAS ENVIADAS Y RECIBIDAS DEL CLIENTE CONTROLADAS A CONTINUACION
  // //////////////////////////////////////////////////////////////////////////////////////////////  



  
  }
 
    
    

  
  
  imprimirpunto("--LOOP: END--",client2);
  
  delay(2000);

}





// ------------------------------------------------------------ OTRAS FUNCIONES ------------------------------------------------------------
 
// FUNCION setdata: al final.

// //////////////////////////////////

// FUNCIONES RTC

// //////////////////////////////////


void setDateTime(){

  Serial.println("--SETDATETIME1--");  
  
  Wire.beginTransmission(DS1307_ADDRESS);
  
  Serial.println("--SETDATETIME2--"); 
  
  Wire.send((byte)0x00); //parar oscilador
  Wire.send((byte)decToBcd(second));
  Wire.send((byte)decToBcd(minute));
  Wire.send((byte)decToBcd(hour));
  Wire.send((byte)decToBcd(weekDay));
  Wire.send((byte)decToBcd(monthDay));
  Wire.send((byte)decToBcd(month));
  Wire.send((byte)decToBcd(year));
  Wire.send((byte)0x00); //comenzar
  
  Serial.println("--SETDATETIME3--"); 
  delay(250);
  Wire.endTransmission();
  Serial.println("--SETDATETIME4--"); 

}

byte decToBcd(byte val){
// Conversion decimal a codigo binario
   return ( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)  {
// Conversion codigo binario a decimal
   return ( (val/16*10) + (val%16) );
}

void printDate(){
  
  //Serial.println("--PRINTDATE1--");   
  
  // Reset register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.send((byte)0x00);
  Wire.endTransmission();
  
  delay(20);
    
  //Serial.println("--PRINTDATE2--");   

  Wire.requestFrom(DS1307_ADDRESS, 7);
  delay(20);
  
  //Serial.println("--PRINTDATE3--");  
  
  second = bcdToDec(Wire.receive());
    delay(20);
  minute = bcdToDec(Wire.receive());
    delay(20);
  hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
    delay(20);
  weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
    delay(20);
  monthDay = bcdToDec(Wire.receive());
    delay(20);
  month = bcdToDec(Wire.receive());
    delay(20);
  year = bcdToDec(Wire.receive());
    delay(20);

  //Serial.println("--PRINTDATE4--");
  
  Serial.print(month);
  Serial.print("/");
  Serial.print(monthDay);
  Serial.print("/");
  Serial.print(year);
  Serial.print(" ");
  Serial.print(hour);
  Serial.print(":");
  Serial.print(minute);
  Serial.print(":");
  Serial.println(second);
  //Serial.println("--PRINTDATE5--");   
 

}


// //////////////////////////////////

// SENSORES DE TEMPERATURA

// //////////////////////////////////


//--LOCAL--:funcion para mostrar temperatura medida por un sensor
//void printTemperature(DeviceAddress deviceAddress)
//{
//  float tempC = sensors.getTempC(deviceAddress);
//  Serial.print("Temp C: ");
//  Serial.flush();
//  Serial.print(tempC);
//  Serial.flush();
//  Serial.print(" Temp F: ");
//  Serial.flush();
//  Serial.println(DallasTemperature::toFahrenheit(tempC)); //grados C a grados Fahrenheit
//  Serial.flush();
//  
//}
//
////--LOCAL--:funcion para mostrar direccion de un sensor
//void printAddress(DeviceAddress deviceAddress)
//{
//  for (uint8_t i = 0; i < 8; i++)
//  {
//    if (deviceAddress[i] < 16) Serial.print("0");
//    Serial.print(deviceAddress[i], HEX);
//    Serial.flush();
//  }
//}
//
////funcion para mostrar la direccion de un sensor
//char* getAddress(DeviceAddress deviceAddress)
//{
//  char* dir=(char*) calloc(16,sizeof(char));
//  Utils.cleardir();
//  Utils.hex2str(deviceAddress, Utils.dir);
//  dir=Utils.dir;
//  return dir;
//  
//}


// //////////////////////////////////

// SETDATA

// //////////////////////////////////

// Envio de los datos al cliente procedentes de los siguientes dispositivos
/*****************
device=0 unknown
device=1 inout1
device=2 inout2
device=3 rfid
device=4 balanza
device=5 DS18B20
device=6 SHT71
******************/

void setdata(Client client, char device, char* info)
{
  
	//printDate();
	char trama[500];
	char aux[200];
	char aux_float[6];

	char devicebuff[2]={device};
	char eventobuff[100];
	//itoa(evento,eventobuff,10);




    	Serial.println("--SETDATA1--");   

      	strcpy(trama, "SET;");
	strcat(trama,devicebuff); 
        strcat(trama,";");

      
    if(device!='5' && device!='6'){  


      
        Serial.println("--SETDATA2--");   

      //incremento contador evento como max. 65635
      if(evento>=30000){
          evento=0;
      }else{    
          evento++;
      }
      
      itoa(evento,eventobuff,10);

      strcat(trama,eventobuff);
      strcat(trama,";"); 
           
       
      if(device=='1' || device=='2'){   //Envio del evento del receptor IR 1 o 2
                                        //SET;1;evento;fechaRTC
                                        //SET;2;evento;fechaRTC



                                        
        Serial.println("--SETDATA3--");   

	addDate(trama);

        Serial.println(trama);  

        client.println(trama);


      }else{  //Envio del dato (info) del lector RFID (3) o de la balanza (4)
              //SET;3;evento;info;fechaRTC
              //SET;4;evento;info;fechaRTC
             
        strcat(trama,info);
        strcat(trama,";");



        Serial.println("--SETDATA4--");

	addDate(trama);

        Serial.println(trama); 

        client.println(trama);

      }
       
    
    }else{  //Envio de la medida (info) del sensor de t. o sensor de t. y hum.
            //SET;5;info;fechaRTC
            //SET;6;info;fechaRTC




        Serial.println("--SETDATA5--");

        strcat(trama,info);
        strcat(trama,";");
 
	addDate(trama);

        Serial.println(trama); 

        client.println(trama);
    
    }
    


        Serial.println("--SETDATA6--"); 

    // delay(300) en la version anterior
    // MODIFICACIONES JULIO
    //delay(100);
    delay(50);

}


void addDate(char* trama){   //Añade fecha a la trama: "DiaMes/Mes/Año Hora:Minuto:Segundo;" (dos digitos cada uno)

	printDate();

	char monthbuff[3];
	itoa(month,monthbuff,10);
	char monthDaybuff[3];
	itoa(monthDay,monthDaybuff,10);
	char yearbuff[3];
	itoa(year,yearbuff,10);
	char hourbuff[3];
	itoa(hour,hourbuff,10);
	char minutebuff[3];
	itoa(minute,minutebuff,10);
	char secondbuff[3];
	itoa(second,secondbuff,10);

        int reintento = 0;

////////////////////////////////////////////////////
        monthbuff[2]='\0';
        monthDaybuff[2]='\0';
        yearbuff[2]='\0';
        hourbuff[2]='\0';
        minutebuff[2]='\0';
        secondbuff[2]='\0';
////////////////////////////////////////////////////

        if( month!=atoi(monthbuff) || monthDay!=atoi(monthDaybuff) || year!=atoi(yearbuff) || second!=atoi(secondbuff) || minute!=atoi(minutebuff) || hour!=atoi(hourbuff)){
        
                addDate(trama);
                Serial.println("reintentando insertar fecha rtc");
                reintento = 1;
        }
        
        
        if(reintento==0){

      
        Serial.println("--ADDDATE1--"); 

//	printDate();



        Serial.println("--ADDDATE2--"); 

        Serial.print("monthDay: ");
        Serial.println(monthDaybuff);
        strcat(trama,monthDaybuff);

        strcat(trama,"/");

        Serial.print("month: ");
        Serial.println(monthbuff);
        strcat(trama,monthbuff);

        strcat(trama,"/");

        Serial.print("year: ");
        Serial.println(yearbuff);
        strcat(trama,yearbuff);

        strcat(trama," ");

        Serial.print("hour: ");
        Serial.println(hourbuff);
        strcat(trama,hourbuff);

        strcat(trama,":");

        Serial.print("minute: ");
        Serial.println(minutebuff);
        strcat(trama,minutebuff);

        strcat(trama,":");

        Serial.print("second: ");
        Serial.println(secondbuff);
        strcat(trama,secondbuff);

        strcat(trama,";"); 



        Serial.println("--ADDDATE3--"); 
        
        }


}

void pedirTemperatura(void){
  
   Serial.println("***LECTURA ALTERNATIVA DE TEMPERATURA***");
 
  Serial.println("***SENSOR 1 EXTERNO***");

//  Serial.print("DIRECCION SENSOR 1 = ");
//
//  for( i = 0; i < 8; i++) {
//    Serial.print(addr1[i], HEX);
//    Serial.print(" ");
//  }

  //Serial.println(" ");

  //if ( OneWire::crc8( addr1, 7) != addr1[7]) {
  //	Serial.print("CRC is not valid!\n");
  //	return;
  //}

  //if ( addr1[0] != 0x28) {
  //	Serial.print("Device is not a DS18S20 family device.\n");
  //	return;
  //}

  oneWire.reset();
  delay(100);
  oneWire.select(addr1);
  delay(100);
  oneWire.write(0x44,1);	   // start conversion, with parasite power on at the end
  delay(1000);                     // maybe 750ms is enough, maybe not
  present = oneWire.reset();
  delay(100);
  oneWire.select(addr1);
  delay(100);
  oneWire.write(0xBE);	           // read Scratchpad
  delay(100);

//  Serial.print("BYTE LEIDOS = ");
//  Serial.print(present,HEX);
//  Serial.print(" ");
  for ( i = 0; i < 9; i++) {
    data[i] = oneWire.read();
//    Serial.print(data[i], HEX);
//    Serial.print("  ");
  }

  Serial.println(" ");
  
  Temp1=(data[1]<<8)+data[0];      //two bytes from the response relating to temperature
  Temp1=Temp1/16;

  Serial.print("TEMPERATURA SENSOR 1 = ");
  Serial.print(Temp1);
  Serial.println("  ");

//  Serial.print(" CRC = ");
//  Serial.print( OneWire::crc8( data, 8), HEX);
//  Serial.println();
  

  Serial.println("***SENSOR 2 INTERNO***");

//  Serial.print("DIRECCION SENSOR 2 = ");
//  
//  
//  for( i = 0; i < 8; i++) {
//    Serial.print(addr2[i], HEX);
//    Serial.print(" ");
//  }

  //Serial.println(" ");

  //if ( OneWire::crc8( addr, 7) != addr2[7]) {
  //	Serial.print("CRC is not valid!\n");
  //	return;
  //}

  //if ( addr2[0] != 0x28) {
  //	Serial.print("Device is not a DS18S20 family device.\n");
  //	return;
  //}

  oneWire.reset();
  delay(100);
  oneWire.select(addr2);
  delay(100);
  oneWire.write(0x44,1);	   // start conversion, with parasite power on at the end
  delay(1000);                     // maybe 750ms is enough, maybe not
  present = oneWire.reset();
  delay(100);
  oneWire.select(addr2);
  delay(100);
  oneWire.write(0xBE);	           // read Scratchpad
  delay(100);

//  Serial.print("BYTES LEIDOS = ");
//  Serial.print(present,HEX);
//  Serial.print(" ");
  for ( i = 0; i < 9; i++) {
    data[i] = oneWire.read();
//    Serial.print(data[i], HEX);
//    Serial.print("  ");
  }

  Serial.println(" ");

  Temp2=(data[1]<<8)+data[0];     //two bytes from the response relating to temperature
  Temp2=Temp2/16;

  Serial.print("TEMPERATURA SENSOR 2 = ");
  Serial.print(Temp2);
  Serial.println("  ");

//  Serial.print(" CRC = ");
//  Serial.print( OneWire::crc8( data, 8), HEX);
//  Serial.println();


 Serial.println("***FIN LECTURA DE TEMPERATURA***");
   
  
}


void imprimirpunto(char* punto, Client client3){ 
  
   Serial.println(punto);
 
   if(client3.connected()==true){
     client3.println(punto);}
    
}


void seleccionnido(void){
  
  //NIDO -  A   - B   - XY-Z EXT. - XY-Z INT.
  //PRUEBA 100  - 00  -    --     -   --
  //6E2  - 101  - 01  - CEBE-22   - 7EF2-ED
  //6E1  - 102  - 02  - 2CEB-22   - 91E0-1F
  //6N7  - 103  - 03  - 4EFC-A2   - ADF0-F3
  //6N6  - 104  - 04  - 1AD7-D8   - F6B1-01
  //6N5  - 105  - 05  - 09E2-8C   - A4EA-A4
  //6N4  - 106  - 06  - 90BD-51   - 9AD1-AE
  //6N3  - 107  - 07  - CFBC-96   - DEE6-D2
  //6N2  - 108  - 08  - 99B2-A8   - DBED-49
  //6N1  - 109  - 09  - A5CF-B9   - F1C3-6A
  //6W3  - 110  - 10  - 70D0-85   - 3FD3-9A
  //6W2  - 111  - 11  - ABCC-E4   - 86BB-24
  //6W1  - 112  - 12  - 01DC-0B   - C1BA-19
  //6S7  - 113  - 13  - 0FB8-16   - DDEE-B5
  //6S6  - 114  - 14  - F4BD-4E   - FCFA-57
  //6S5  - 115  - 15  - 64B0-13   - 50CC-6E
  //6S4  - 116  - 16  - E2C4-39   - 33B0-B8
  //6S3  - 117  - 17  - D2F7-1E   - 40F8-AE
  //6S2  - 118  - 18  - A9D0-D7   - 83C5-00
  //6S1  - 119  - 19  - 4DDB-52   - 85DC-3D
  //6E3  - 120  - 20  - F9F2-82   - 1BB8-91
  //PRUEBA 121  - 21  - 0000-00   - 1111-11 
  
  //IP:192.168.2.A
  //MAC(HEX):00-02-D1-04-22-B
  //SENSOR T(HEX):28-X-Y-15-03-00-00-Z};
  
  //Serial.println("--SELECCION NIDO--");

  if(strcmp(nido,"6E2")==0)
  {
    asignacionparametros(101,0x1,0xCE, 0xBE, 0x22, 0x7E, 0xF2, 0xED, "CEBE227EF2ED");
  }else if(strcmp(nido,"6E1")==0)
  {
    asignacionparametros(102,0x2,0x2C, 0xEB, 0x22, 0x85, 0xB8, 0x33, "2CEB22862833");
  }else if(strcmp(nido,"6N7")==0)
  {
    asignacionparametros(103,0x3,0x4E, 0xFC, 0xA2, 0xAD, 0xF0, 0xF3, "4EFCA2ADF0F3");
  }else if(strcmp(nido,"6N6")==0)
  {
    asignacionparametros(104,0x4,0x1A, 0xD7, 0xD8, 0xF6, 0xB1, 0x01, "1AD7D8F6B101");
  }else if(strcmp(nido,"6N5")==0)
  {
    asignacionparametros(105,0x5,0x09, 0xE2, 0x8C, 0xA4, 0xEA, 0xA4, "09E28CA4EAA4");
  }else if(strcmp(nido,"6N4")==0)
  {
    asignacionparametros(106,0x6,0x90, 0xBD, 0x51, 0x9A, 0xD1, 0xAE, "90BD519AD1AE");
  }else if(strcmp(nido,"6N3")==0)
  {
    asignacionparametros(107,0x7,0xCF, 0xBC, 0x96, 0xDE, 0xE6, 0xD2, "CFBC96DEE6D2");
  }else if(strcmp(nido,"6N2")==0)
  {
    asignacionparametros(108,0x8,0x99, 0xB2, 0xA8, 0xDB, 0xED, 0x49, "99B2A8DBED49");
  }else if(strcmp(nido,"6N1")==0)
  {
    asignacionparametros(109,0x9,0xA5, 0xCF, 0xB9, 0xF1, 0xC3, 0x6A, "A5CFB9F1C36A");
  }else if(strcmp(nido,"6W3")==0)
  {
    asignacionparametros(110,0x10,0x70, 0xD0, 0x85, 0x3F, 0xD3, 0x9A, "70D0853FD39A");
  }else if(strcmp(nido,"6W2")==0)
  {
    asignacionparametros(111,0x11,0xAB, 0xCC, 0xE4, 0x86, 0xBB, 0x24, "ABCCE486BB24");
  }else if(strcmp(nido,"6W1")==0)
  {
    asignacionparametros(112,0x12,0x01, 0xDC, 0x0B, 0xC1, 0xBA, 0x19, "01DC0BC1BA19");
  }else if(strcmp(nido,"6S7")==0)
  {
    asignacionparametros(113,0x13,0x0F, 0xB8, 0x16, 0xDD, 0xEE, 0xB5, "0FB816DDEEB5");
  }else if(strcmp(nido,"6S6")==0)
  {
    asignacionparametros(114,0x14,0xF4, 0xBD, 0x4E, 0xFC, 0xFA, 0x57, "F4BD4EFCFA57");
  }else if(strcmp(nido,"6S5")==0)
  {
    asignacionparametros(115,0x15,0x64, 0xB0, 0x13, 0x50, 0xCC, 0x6E, "64B01350CC6E");
  }else if(strcmp(nido,"6S4")==0)
  {
    asignacionparametros(116,0x16,0xE2, 0xC4, 0x39, 0x33, 0xB0, 0xB8, "E2C43933B0B8");
  }else if(strcmp(nido,"6S3")==0)
  {
    asignacionparametros(117,0x17,0xD2, 0xF7, 0x1E, 0x40, 0xF8, 0xAE, "D2F71E40F8AE");
  }else if(strcmp(nido,"6S2")==0)
  {
    asignacionparametros(118,0x18,0xA9, 0xD0, 0xD7, 0x83, 0xC5, 0x00, "A9D0D783C500");
  }else if(strcmp(nido,"6S1")==0)
  {
    asignacionparametros(119,0x19,0x4D, 0xDB, 0x52, 0x85, 0xDC, 0x3D, "4DDB5285DC3D");
  }else if(strcmp(nido,"6E3")==0)
  {
    asignacionparametros(120,0x20,0xF9, 0xF2, 0x82, 0x1B, 0xB8, 0x91, "F9F2821BB891");
  }else if(strcmp(nido,"PRB")==0) {
    asignacionparametros(121,0x21,0x00, 0x00, 0x00, 0x11, 0x11, 0x11, "000000111111");
  }
  
  
} 

 void asignacionparametros(byte ipA, byte macB, byte Xext, byte Yext, byte Zext, byte Xint, byte Yint, byte Zint, char *addrc){
   
  //IP:192.168.2.A
  //MAC(HEX):00-02-D1-04-22-B
  //SENSOR T(HEX):28-X-Y-15-03-00-00-Z};
  //                 0    1       2       3         4     5        6      7
  //byte mac[] = { 0x00, 0x02,   0xD1,   0x04,     0x22, 0xmacB };
  //byte ip[] =   { 192, 168,    2,      macB+100};
  //byte addr1[8]={0x28, 0xXext, 0xYext, 0x15,     0x03, 0x00,    0x00, 0xZext};  //SENSOR EXTERNO
  //byte addr1[8]={0x28, 0xXint, 0xYint, 0x15,     0x03, 0x00,    0x00, 0xZint};  //SENSOR INTERNO
  
    
  mac[5]= macB;
  ip[3]= ipA;
  addr1[1]= Xext;
  addr1[2]= Yext;
  addr1[7]= Zext;
  addr2[1]= Xint;  
  addr2[2]= Yint;
  addr2[7]= Zint;
  
  //char addr1c[17]={'2','8',addrc[0],addrc[1],addrc[2],addrc[3],'1','5','0','3','0','0','0','0',addrc[4],addrc[5]','\0'};
  //char addr2c[17]={'2','8',addrc[6],addrc[7],addrc[8],addrc[9],'1','5','0','3','0','0','0','0',addrc[10],addrc[11],'\0'};
  addr1c[2]=addrc[0];
  addr1c[3]=addrc[1];
  addr1c[4]=addrc[2];
  addr1c[5]=addrc[3];
  addr1c[14]=addrc[4];
  addr1c[15]=addrc[5];
  addr2c[2]=addrc[6];
  addr2c[3]=addrc[7];
  addr2c[4]=addrc[8];
  addr2c[5]=addrc[9];
  addr2c[14]=addrc[10];
  addr2c[15]=addrc[11];
  
}




 









